home *** CD-ROM | disk | FTP | other *** search
/ Die Ultimative Software-P…i Collection 1996 & 1997 / Die Ultimative Software-Pakete CD-ROM fur Atari Collection 1996 & 1997.iso / m / mailbox / mystery / applic / app.c next >
Encoding:
C/C++ Source or Header  |  1996-09-18  |  35.8 KB  |  1,243 lines
  1. /****************************************************************************
  2. '
  3. '               Header fuer Mystery-Applikationen unter MEGAMAX-C
  4. '                          Copyright PARROT-BERLIN
  5. '
  6. '
  7. ' Dieser Header stellt I/O-Routinen für MEGAMAX-C, sowie einige Systemvari-
  8. ' ablen von Mystery-Systems zur Verfügung.
  9. ' Es sind ausschließlich die angebotenen I/O-Routinen zu verwenden, die
  10. ' RS232C-Schnittstelle darf nicht umkonfiguriert werden.
  11. '
  12. ' Die angebotenen I/O-Routinen zeichnen sich dadurch aus, dass sie auf Kon-
  13. ' trollcodes, Carrierverlust, Timeout und Ueberschreiten der maximalen Benut-
  14. ' zerzeit reagieren und per longjmp Stellen im Programm anspringen, die vor-
  15. ' her mit setjmp markiert wurden. Generell lassen sich vier Typen von Events
  16. ' unterscheiden, fuer die zwei Environmentbuffer angelegt wurden (Termina-
  17. ' te_env und Break_env).
  18. '                                                       
  19. ' Benutzung der Jump-buffer                            
  20. '                                                       
  21. ' Event        abfragende Routinen      Buffer         
  22. '                                                       
  23. ' Carrier_lost Mbputchar/Mbgetchar      Terminate_env    
  24. ' t>tmax       Mbputchar                Terminate_env   
  25. ' timeout      Mbgetchar                Terminate_env   
  26. ' CTRL-X       ctrl                     Break_env       
  27. '                                                       
  28. '
  29. ' Prinzipiell muessen die Environmentbuffer vor der Benutzung von I/O-Routi-
  30. ' nen korrekt gesetzt sein, da es sonst zu Abstuerzen kommt. Damit die ganze
  31. ' Angelegenheit nicht unnoetig kompliziert wird, wird empfohlen, nur
  32. ' Break_env zu veraendern, damit das Programm auf CTRL_X reagiert.
  33. '
  34. ' Die Routinen sind weitgehend den Standardroutinen von C nachempfunden, als
  35. ' weitere Parameter werden jedoch haeufig BRK, NBRK und NCTRL verwendet. Die-
  36. ' se Parameter legen fest, ob die Ausgabe abgebrochen werden kann oder nicht.
  37. ' NCTRL wirkt dabei wie NBRK mit der zusaetzlichen Eigenschaft, dass RS232C
  38. ' generell nicht auf Kontrollcodes abgefragt wird.
  39. '
  40. ' Als weitere Besonderheit soll noch erwaehnt werden, dass die MORE- und die
  41. ' Slow-Option beim Programmstart von Mystery-Systems uebernommen werden,
  42. ' weiterhin weist Mbgets den Inline-Editor von Mystery-Systems auf.
  43.  
  44. ' Die compilierten Programme müssen die Extension .APP haben!!
  45. '
  46. '
  47. ' Sofern die folgenden Funktionen nicht ausreichend sein sollten oder
  48. ' Unklarheiten bestehen, bitte die PARROT unter (030) 724467 anrufen und
  49. ' eine PM an den Syop senden, bzw. eine Nachricht ins Visitors.brd setzen.
  50. ' 
  51. '
  52. ' ACHTUNG: DIE ROUTINEN DIESES FILES SIND NICHT PUBLIC-DOMAIN, SIE DUERFEN
  53. '          ABER NICHTKOMMERZIELL VERWERTET WERDEN.
  54. '
  55. '
  56. '            Mit freundlichen Gruessen
  57. '
  58. '                     Horst
  59. '
  60. '
  61. '
  62. '***************************************************************************/
  63.  
  64. #include <osbind.h>
  65. #include <define.h>
  66. #include <string.h>
  67. #include <stdio.h>
  68. #include <errno.h>
  69. #include <ctype.h>
  70.  
  71.  
  72. /****************************************************************************
  73.  
  74.           Defines und Strukturen
  75.           
  76. ****************************************************************************/
  77.  
  78. #define   AUX             1
  79. #define   CON             2
  80.  
  81. #define   DEL          0x7F        /* Deletecodes f. verschiedene Computer */
  82. #define   BS              8
  83.  
  84. #define   CTRL_E          5
  85. #define   BEL             7
  86. #define   CR             13
  87. #define   CTRL_S         19
  88. #define   UP_ARROW       22       
  89. #define   DOWN_ARROW     23    
  90. #define   CTRL_X         24
  91. #define   RIGHT_ARROW    25
  92. #define   LEFT_ARROW     26
  93. #define   ESC            27 
  94.  
  95. #define   F1             59L       /* Scancodes */ 
  96. #define   F2             60L
  97. #define   F3             61L
  98. #define   F4             62L
  99. #define   F5             63L
  100. #define   F6             64L
  101. #define   F7             65L
  102. #define   F8             66L
  103. #define   F9             67L
  104. #define   F10            68L
  105.  
  106.  
  107. #define   A_ae          132        /* Umlaute, Sonderzeichen */
  108. #define   A_oe          148        /* A=Atari, Am=Amiga, M=Mac, PC=PC, E=EASCII */
  109. #define   A_ue          129
  110. #define   A_AE          142
  111. #define   A_OE          153
  112. #define   A_UE          154
  113. #define   A_SZ          158
  114. #define   A_PA          0xDD
  115.  
  116. #define   PC_SZ         0xE1    /* Rest ist wie Atari */
  117.  
  118. #define   SCRNWIDTH      79
  119. #define   BACKSPACE       Mbprintf(NCTRL,"\b \b")
  120. #define   CRLF            Mbprintf(NCTRL,"\r\n")
  121. #define   BELL            Mbputchar('\007',NBRK)                                     /* leer ist, ausserdem WERDEN KEINE USERINPUTS GESCHLUCKT */
  122. #define   VT_LEFT         Rsout("\033[D")
  123. #define   VT_RIGHT        Rsout("\033[C")
  124. #define   VT_STORE        Rsout("\0337")
  125. #define   VT_REST         Rsout("\0338")
  126. #define   VT_INSERT       Rsout("\033[4h")
  127. #define   VT_OVER         Rsout("\033[4l")
  128. #define   VT_DEL          Rsout("\033[1P")
  129. #define   VT_DELEOL       Rsout("\033[K") 
  130.  
  131. #define SCRN(a) bios(3,2,ESC); bios(3,2,a)
  132.  
  133. #define CRSR_UP SCRN('A')
  134. #define CRSR_DOWN SCRN('B')
  135. #define CRSR_RT SCRN('C')
  136. #define CRSR_LT SCRN('D')
  137. #define CLRSCRN SCRN('E')
  138. #define HOME SCRN('H')
  139. #define DEL_EOP SCRN('J')
  140. #define DEL_EOL SCRN('K')
  141. #define INSRT_LIN SCRN('L')
  142. #define KILL_LIN SCRN('M')
  143. #define CRSR_OFF SCRN('f')
  144. #define CRSR_ON SCRN('e')
  145. #define DEL_BOS SCRN('d')
  146. #define STORE_CRSR SCRN('j')
  147. #define RESTORE_CRSR SCRN('k')
  148. #define DEL_LIN SCRN('l')
  149. #define DEL_BOL SCRN('o')
  150. #define REV_ON SCRN('p')
  151. #define REV_OFF SCRN('q')
  152. #define WRAP_ON SCRN('v')
  153. #define WRAP_OFF SCRN('w')
  154. #define BGD_WHITE SCRN('c'); bios(3,2,0x30);
  155. #define BGD_BLACK SCRN('c'); bios(3,2,0x31);
  156.  
  157. #define GOTO(x,y) SCRN('Y'); bios(3,2,y+32); bios(3,2,x+32)
  158.  
  159.  
  160. #define   NBRK            0
  161. #define   BRK             1
  162. #define   NCTRL           2
  163.  
  164.  
  165. typedef struct
  166. {
  167.      unsigned BATCHING: 1;         /* true, wenn Batchbetrieb */
  168.      unsigned NOENTRY: 1;          /* true, wenn kein access auf rootdirectory moeglich ist */
  169.      unsigned SYSOUT:  1;          /* true, wenn System logoff durchfuehrte */
  170.      unsigned CARRIER_LOST: 1;     /* true wenn carrier-lost */
  171.      unsigned TOUT: 1;             /* true wenn timeout */
  172.      unsigned TMAX: 1;             /* true wenn maxtime ueberschritten */
  173.      unsigned BELLOFF: 1;          /* true wenn belloff */
  174.      unsigned LOCAL: 1;            /* true wenn localbetrieb */
  175.      unsigned SLOW: 1;             /* true fuer langsame Ausgabe */
  176.      unsigned CAT: 1;              /* true, wenn Katalog geladen */
  177.      unsigned MORE: 1;             /* true fuer Anhalten bei Boards u. Mails */
  178.      unsigned DIROWNER: 1;         /* true, wenn User Owner des aktuellen Directories ist */
  179.      unsigned ERROR: 1;            /* bei true werden Fehler angezeigt */ 
  180.      unsigned LONG: 1;             /* true, wenn langer Catalog angezeigt werden soll */
  181.      unsigned UPDATE: 1;           /* true, wenn Catalog zurueckgeschrieben werden muss */
  182.      unsigned LOGOUT: 1;           /* true bei logout durch den user */
  183. } FLAG;
  184.  
  185. typedef struct
  186. {
  187.      unsigned KILL_MAIL: 1;        /* true, wenn Mail gelesen wurde und geloescht werden kann */
  188.      unsigned PRINTER: 1;          /* wenn true, erfolgen Ausgaben auch auf Printer */
  189.      unsigned OPTION: 1;           /* wenn true, Option zum Schreiben nach dem Lesen eines Boards */
  190.      unsigned EXPAND: 1;           /* wenn true, kein cr-lf vor und nach errors */
  191.      unsigned NO_ECHO: 1;          /* wenn true, einmalig kein Echo bei Mbgets */
  192.      unsigned HIDE: 1;             /* wenn true, Ausgabe erst ab 'logged in at... */
  193.      unsigned INTERPRET: 1;        /* ermoeglicht UP_ARROW und DOWN_ARROW */
  194.      unsigned INSERT: 1;           /* true, wenn Userterminal auf Insert geschaltet wurde */
  195.      unsigned EDITLINE: 1;         /* true, wenn Zeile im Editor editiert werden soll */
  196.      unsigned INFO: 1;             /* true, wenn bei Catalogen das Readdatum der Items ausgegeben werden soll */
  197.      unsigned NOSPOOL: 1;          /* gesetzt durch Option Nospool beim Einloggen->Read-zugriffe werden nicht registriert */
  198.      unsigned INFOLINE: 1;         /* wenn true, wird Infoline angezeigt */
  199. } FLAG2;
  200.   
  201. typedef struct 
  202. {
  203.      char NAME[21];
  204.      char CLASS[3];           
  205.      char GROUP[5];      
  206.      char DATE[9];
  207.      char TIME[9];
  208.      char CALLS[7]; 
  209. } USER;
  210.  
  211. typedef struct 
  212. {
  213.      char *IBUFF;
  214.      int IBUFSIZ;
  215.      int IBUFTL;
  216.      int IBUFHD;
  217.      int IBUFLOW;
  218.      int IBUFHI;
  219.      long *OBUFF;
  220.      int OBUFSIZ;
  221.      int OBUFTL;
  222.      int OBUFHD;
  223.      int OBUFLOW;
  224.      int OBUFHI;
  225. } RSIOREC;
  226.  
  227. typedef struct 
  228. {
  229.      unsigned sec:  5;
  230.      unsigned min:  6;
  231.      unsigned hour: 5;
  232. } ZEITFELD;
  233.  
  234. typedef struct 
  235. {
  236.      int SEKUNDEN;
  237.      int MINUTEN;
  238.      int STUNDEN;
  239. } UHRZEIT;
  240.  
  241. typedef struct
  242. {
  243.      FLAG    *APP_FLAG;        /* Pointer auf Systemflags1           */
  244.      FLAG2   *APP_FLAG2;       /* Pointer auf Systemflags2           */
  245.      USER    *APP_USER;        /* Pointer auf Userdaten              */ 
  246.      char    *APP_SYSPATH;     /* Pfad ins Systemdirectory           */
  247.      char    *APP_CATBUFF;     /* Pointer auf Catalogbuffer          */
  248.      long    *APP_CATCOUNT;    /* Länge des Catalogs                 */
  249.      long    APP_CALLS;        /* aktuelle Zahl der Anrufe           */
  250.      int     APP_TMAX;         /* maximale Benutzerzeit in min.      */
  251.      long    APP_LOGINTIME;    /* Einlogzeit in s (24:00=0s)         */
  252.      int     APP_BAUD;         /* aktuelle Baudrate                  */
  253.      int     APP_SCREENSIZE;   /* Screengroesse des Users in Zeilen  */ 
  254.      char    *APP_ICNVRT;      /* Pointer auf Inputwandlungstabelle  */
  255.      char    *APP_OCNVRT;      /* Pointer auf Outputwandlungstabelle */
  256. } APP_PAR;
  257.  
  258. extern long atol();
  259.  
  260. /****************************************************************************
  261.  
  262.         Fuer den Programmierer der Applikation interessante Variablen
  263.            
  264. ****************************************************************************/
  265.  
  266. FLAG  *Flag;                   /* Pointer auf Mystery Flags         */
  267. FLAG2 *Flag2;                  /* Pointer auf Mystery Flag2         */
  268. USER  *User;                   /* Pointer auf Userstruktur          */
  269. long Calls;                    /* Anzahl der Anrufer                */
  270. long Time;                     /* Zwischenspeicher fuer Zeiten in s */
  271. int  Touttime=60;              /* Zeit fuer Timeout in s            */
  272. int  Tmax;                     /* aktuelle maximale Benutzerzeit    */
  273. long Login_time;               /* Einlogzeit des Users in Sekunden  */
  274. int Cr_count;                  /* Zeilenzaehler fuer MORE           */ 
  275. jmp_buf Terminate_env;         /* fuehrt normalerweise nach exit    */
  276. jmp_buf Break_env;             /* muss vor I/O definiert werden     */
  277. int Screensize;                /* Groesse (Zeilen) des Userscreens  */
  278. char *Convert_oarray;          /* Zeiger auf Outputwandlungstabelle */
  279. char *Convert_iarray;          /* Zeiger auf Inputwandlungstabelle  */
  280.  
  281. /****************************************************************************
  282.  
  283. *****************************************************************************
  284.  
  285.                          some stuff
  286.                          
  287. ****************************************************************************/
  288.  
  289. char *Rsbuff;
  290. int Last_char=0;
  291. long *hz_200 = (long *) 0x000004ba;
  292.  
  293. UHRZEIT Uhrzeit;
  294.  
  295.  
  296. int Last_input;                /* gespeichert durch ctrl bei NBRK */
  297.  
  298. RSIOREC *new_rsiorec;
  299.  
  300. short int *MFP = 0xFFFA01;
  301.  
  302. APP_PAR *App_par;   /* bekommen wir als erstes Argument uebergeben */
  303.  
  304. long Ti()                          /* Uhrzeit in Sekunden   */
  305. {
  306.      long time;
  307.  
  308.      Zeit();
  309.      time = Uhrzeit.STUNDEN * 3600L + Uhrzeit.MINUTEN * 60L + (long)Uhrzeit.SEKUNDEN;
  310.      return(time);
  311. }
  312.  
  313. Carrier()                /* prueft auf CARRIER */
  314. {
  315.      short int  n;         
  316.      long save_ssp;
  317.  
  318.      save_ssp = Super(0L);
  319.      n = *MFP;
  320.      Super(save_ssp);
  321.      n = !((n & 2) >> 1);        
  322.      return(n);                 /* n=true if carrier */                        
  323. }
  324.  
  325.  
  326. /***************************************************************************/
  327. /*                                                                         */
  328. /* Erlaeuterungen zu I/O und Longjumps                                     */
  329. /*                                                                         */
  330. /* Terminate_env muss vor allen I/O-Operationen korrekt gesetzt sein.      */
  331. /*                                                                         */
  332. /* Break_env muss vor allen Ausgabeoperationen gesetzt sein, bei denen     */
  333. /* BRK erlaubt ist.                                                        */
  334. /*                                                                         */
  335. /*                                                                         */
  336. /*                                                                         */
  337. /***************************************************************************/
  338.  
  339.  
  340. Sterminal()     /* 0 oder Zeichen von RS232C                */
  341.                 /* wenn !Carrier(), dann wird kein Zeichen  */
  342. {               /* angenommen                               */
  343.      int c=0;
  344.                            
  345.      if(Bconstat(AUX)&&Carrier())                           
  346.           c = Bconin(AUX);
  347.           
  348.      return(c);
  349. }
  350.  
  351. Terminal()           /* Holt Zeichen von der Console */
  352. {
  353.      long c=0;
  354.      int scancode;
  355.      
  356.      if(Bconstat(CON))
  357.      {
  358.           c=Bconin(CON);
  359.           scancode=c>>16;
  360.       
  361.           if(scancode>71 && scancode<81)
  362.           {
  363.                switch(scancode)
  364.                {
  365.                
  366.                     case 75:  c=LEFT_ARROW;
  367.                               break;
  368.                               
  369.                     case 77:  c=RIGHT_ARROW;
  370.                               break;
  371.                               
  372.                     default:  c=0;
  373.                               break;          
  374.                }
  375.                
  376.           }
  377.                                         
  378.      }
  379.      
  380.      return((int)c);
  381. }
  382.  
  383. /****************************************************************************
  384.  
  385.  
  386.           Vom Programmierer der Applikation zu benutzende I/O-Routinen
  387.  
  388.  
  389. ****************************************************************************/
  390.  
  391.  
  392. Mbgetchar()         /* wartet auf Eingabe von RS232C oder Tastatur   */
  393. {                   /* Exit mit char oder CR und Flag.TOUT=1 bei     */
  394.                     /* Timeout oder Flag.CARRIER_LOST=1 bei Carrier- */
  395.                     /* verlust */
  396.                     
  397.      int c; 
  398.      Time = Ti();
  399.  
  400.      Last_char=0;
  401.  
  402.      do
  403.      {
  404.          if(!(c=con_legal(Terminal())))
  405.                c=legal(Sterminal()); 
  406.           
  407.           if(Tout() || Carrier_lost())
  408.                longjmp(Terminate_env,0);       /* Session beenden */            
  409.      }
  410.      while(!c);
  411.  
  412.      return(c);
  413. }
  414.  
  415. Mbputchar(c,mode)        /* Ausgabe auf Schirm und RS232C */
  416. char c;
  417. int mode;                         
  418. {
  419.      char in, auxout1, auxout2, conout1, conout2;
  420.  
  421.      if(Flag->LOCAL)
  422.           conout1=Convert_oarray[2*(unsigned)c];
  423.           
  424.      else
  425.      {
  426.           auxout1=Convert_oarray[2*(unsigned)c];
  427.           auxout2=Convert_oarray[2*(unsigned)c+1];
  428.           conout1=c;
  429.      }
  430.           
  431.      if((Carrier_lost() || Maxtime_exceeded()) && mode==BRK)
  432.      {
  433.           CRLF;
  434.           longjmp(Terminate_env,0);
  435.      }
  436.       
  437.      if(conout1=='\n')
  438.      {
  439.           Cr_count++;
  440.           Bconout(CON,conout1);
  441.      }
  442.                
  443.      else
  444.      {
  445.           if(conout1 != ESC)
  446.                Bconout(CON,conout1);
  447.      }
  448.      
  449.      if(Carrier())
  450.      {
  451.           Bconout(AUX,auxout1);
  452.  
  453.  
  454.           if(auxout2 && Carrier())
  455.                Bconout(AUX,auxout2);          
  456.      }
  457.      
  458.      if(Flag->MORE && conout1=='\n')
  459.      {
  460.           if(Cr_count>(Screensize-1))
  461.           {
  462.                Cr_count=1;
  463.                Mbprintf(NBRK,"<===MORE===>");
  464.                in=More_getchar();
  465.               
  466.                Mbprintf(NBRK,"\r            \r");
  467.                
  468.                if((in==CTRL_X || in=='q') && mode==BRK)
  469.                     longjmp(Break_env,0);
  470.                
  471.                if(in==CTRL_E || in=='Q')
  472.                     longjmp(Terminate_env,0);
  473.           }
  474.      }
  475. }
  476.  
  477. /* wie printf, jedoch ueber Screen und RS232C. Max. 10 Parameter! */
  478. /* mode (BRK, NBRK, NCTRL) bestimmt, ob abgebrochen werden kann.  */            
  479.  
  480. Mbprintf(mode,pointer,p0,p1,p2,p3,p4,p5,p6,p7,p8,p9)
  481. int mode;
  482. char *pointer,*p0,*p1,*p2,*p3,*p4,*p5,*p6,*p7,*p8,*p9;
  483. {
  484.      char puffer[161];
  485.  
  486.      sprintf(puffer,pointer,p0,p1,p2,p3,p4,p5,p6,p7,p8,p9);
  487.      mbtype((long) strlen(puffer),puffer,mode);
  488. }
  489.  
  490. Mbgets(line,count)  /* Routine holt count Zeichen von der Con- */
  491. char *line;         /* sole oder RS232C                        */
  492. int count;
  493. {
  494.      unsigned char inp; 
  495.      char buffer[160];
  496.      int i=0;
  497.      int crsr=0;
  498.  
  499.      if(Flag2->EDITLINE)
  500.      {
  501.           i=crsr=strlen(line);
  502.           
  503.           Mbprintf(NBRK,"\r\n%s",line);
  504.           
  505.           if(i==count)
  506.           {
  507.                CRSR_LT;
  508.                VT_LEFT;
  509.                crsr--;
  510.           }
  511.           
  512.           else
  513.                Flag2->EDITLINE=0;     
  514.      }
  515.  
  516.      else
  517.           line[0]='\0';
  518.   
  519.                
  520.      while (i < (count+Flag2->EDITLINE)) 
  521.      {
  522.           inp=Mbgetchar();
  523.     
  524.           if(is_controll(inp))
  525.                handle_ctrl(inp,&crsr,&i,line);
  526.           
  527.           else 
  528.           {
  529.                if (inp == '\r') 
  530.                     break;
  531.             
  532.                if(i==crsr)
  533.                {
  534.                     line[i++] = inp; line[i] = '\0';
  535.                     Mbputchar(inp,BRK);
  536.                     crsr++;
  537.                }
  538.                
  539.                else
  540.                {
  541.                     if(!Flag2->EDITLINE)
  542.                     {
  543.                          l_insert(inp,line+crsr);
  544.                          crsr++;
  545.                          i++;
  546.                     }     
  547.                }   
  548.           }
  549.      }
  550.      
  551.      if(Flag2->INSERT)
  552.      {
  553.           VT_OVER;
  554.           Flag2->INSERT=0;
  555.      }     
  556.           
  557.      Cr_count=0;     
  558.      CRLF;
  559.  
  560. }
  561.  
  562. /* wie scanf, jedoch ueber Screen und RS232C. Max. 10 Parameter! */
  563. /* maximale Stringlaenge muss vorgegeben werden                  */
  564.  
  565. Mbscanf(count,format,p0,p1,p2,p3,p4,p5,p6,p7,p8,p9)
  566. int count;
  567. char *format,*p0,*p1,*p2,*p3,*p4,*p5,*p6,*p7,*p8,*p9;
  568.  
  569. {
  570.      char puffer[180];
  571.  
  572.      Mbgets(puffer,count);
  573.      strcat(puffer," @ @ @ @ @ @ @ @ @ @ ");  /* das ist hier noetig!! */            
  574.      sscanf(puffer,format,p0,p1,p2,p3,p4,p5,p6,p7,p8,p9);
  575. }
  576.  
  577. Mbputfile(source)   /* gibt geoeffnetes File aus */
  578. FILE *source;
  579. {         
  580.      char c;
  581.      jmp_buf breakstore;
  582.      
  583.      Save_env(Break_env,breakstore); /* Environment saven */
  584.      
  585.      if(!setjmp(Break_env))
  586.      {
  587.           while((c = getc(source)) !=EOF)
  588.           {
  589.                charout(c,BRK);
  590.                ctrl(BRK);
  591.           }
  592.      }
  593.      
  594.      fclose(source);
  595.      
  596.      Save_env(breakstore,Break_env); /* Environment wieder herstellen */
  597. }
  598.  
  599. /****************************************************************************
  600.  
  601.      Andere Routinen, die nuetzlich sein koennten
  602.      
  603. ****************************************************************************/
  604.  
  605. Empty_rsbuf()  /* loescht RS232C-Eingabepuffer */
  606. {
  607.      new_rsiorec->IBUFHD = new_rsiorec->IBUFTL = 0;
  608. }
  609.  
  610. Elapsed_time()      /* returns die seit dem Einloggen verstrichene Zeit in Minuten */
  611. {
  612.      long zeit;
  613.  
  614.      zeit=Ti()-Login_time;
  615.  
  616.      if(zeit<0)
  617.           zeit += 86400;
  618.  
  619.      return((int)(zeit/60));
  620. }
  621.  
  622. Change(pointer) /* setzt String in Grossbuchstaben um */
  623. char *pointer;
  624. {
  625.      while(*pointer)
  626.           *pointer++=toupper(*pointer);
  627. }
  628.  
  629. /****************************************************************************
  630.  
  631.                stuff cont.
  632.                
  633. ****************************************************************************/
  634.  
  635. legal(c)  /*  Ueberprueft Eingaben des Users auf Legalitaet */
  636. int c;    /*  und wandelt ggf auch Deletecodes um */
  637.  
  638. {
  639.      int back;
  640.      static int store;
  641.      
  642.      if(!c)
  643.           return(FALSE);
  644.    
  645.      if(store=='[')
  646.      {
  647.           switch(c)
  648.           {
  649.                case 'A':      store=0;
  650.                               return(UP_ARROW);
  651.                               break;
  652.                               
  653.                case 'B':      store=0;
  654.                               return(DOWN_ARROW);
  655.                               break;
  656.                               
  657.                case 'C':      store=0;
  658.                               return(RIGHT_ARROW);
  659.                               break;
  660.                               
  661.                case 'D':      store=0;
  662.                               return(LEFT_ARROW);
  663.                               break;
  664.                               
  665.                default:       if(c!='1')
  666.                                    store=0;
  667.                               
  668.                               else
  669.                                    return(FALSE);
  670.           }                          
  671.      
  672.      }
  673.  
  674.      if(store==ESC)
  675.      {
  676.           if(c == '[')
  677.           {     
  678.                store=c;
  679.                return(FALSE);
  680.           }
  681.           
  682.           else
  683.                store=0;
  684.      }
  685.      
  686.      if(c==CTRL_S)
  687.           Time=Ti();
  688.  
  689.      if(c==ESC)
  690.           store=ESC;
  691.  
  692.      back=(unsigned)Convert_iarray[c];
  693.    
  694.        
  695.      return(back);
  696. }
  697.  
  698. con_legal(c)  /*  Ueberprueft Eingaben von der Console auf Legalitaet */
  699. int c;        /*  und wandelt ggf auch Deletecodes um */
  700. {
  701.      int back;
  702.      
  703.      switch(c)
  704.      {
  705.           case CTRL_S:   Time=Ti();
  706.                          back=0;
  707.                          break;
  708.           case DEL:
  709.           case BS:
  710.           case CR:               
  711.           case UP_ARROW:
  712.           case DOWN_ARROW:
  713.           case LEFT_ARROW:
  714.           case RIGHT_ARROW:   
  715.           case A_ae:
  716.           case A_oe:
  717.           case A_ue:
  718.           case A_AE:
  719.           case A_OE:
  720.           case A_UE:
  721.           case A_PA:
  722.           case A_SZ:     back=c;
  723.                          break;
  724.                                
  725.           default:       back=(c<32 || c>126) ? 0 : c;
  726.                      
  727.      }
  728.      
  729.      return(back);
  730. }
  731.  
  732. More_getchar()      /* eigenes getchar fuer more, weil sonst ctrl-x nicht beruecksichtigt wird */  
  733. {                  
  734.      int c, store; 
  735.      Time = Ti();
  736.  
  737.      store=Touttime;
  738.      Touttime=300;
  739.      
  740.      do
  741.      {
  742.        if(!(c=Terminal()))
  743.           c=Sterminal();
  744.           
  745.        c=more_legal(c);   
  746.           
  747.        if(Carrier_lost())
  748.           longjmp(Terminate_env,0);       /* Session beenden */
  749.           
  750.        if(Maxtime_exceeded())
  751.           longjmp(Terminate_env,0);       /* Session beenden */
  752.           
  753.        if(Tout())
  754.           longjmp(Terminate_env,0);
  755.      }
  756.      while(!c);
  757.  
  758.      Touttime=store;
  759.      
  760.      return(c);
  761. }
  762.  
  763. more_legal(c)  /*  Ueberprueft Eingaben auf Legalitaet */
  764. int c;  
  765.  
  766. {
  767.      int back;
  768.      
  769.      return(back=((c<32 || c>126) && c!=CTRL_X && c!=CR) ? 0 : c);
  770. }
  771.  
  772. Rsout(string) /* Ausgabe nur ueber Rs323c */
  773. char *string;
  774. {
  775.      while(*string)
  776.      {
  777.           if(Carrier())
  778.                Bconout(AUX,*string);
  779.  
  780.           string++;
  781.      }          
  782. }
  783.  
  784.  
  785. charout(c,mode)          /* Ausgabe fuer Mailbox */
  786. char c;
  787. int mode;
  788. {
  789.      while(new_rsiorec->OBUFHD != new_rsiorec->OBUFTL);
  790.  
  791.      Mbputchar(c,mode);
  792.  
  793.      if(Flag->SLOW)
  794.           Wait(30L);
  795. }
  796.  
  797.  
  798. ctrl(mode)         /* stellt fest, welcher code, wartet bei CTRL_S */
  799. int mode;
  800. {
  801.      register int c;
  802.      
  803.      if(mode==NCTRL)
  804.           return;
  805.  
  806.      if(!(c=Last_char))               
  807.           if(!(c=Terminal()))
  808.                if(!(c=Sterminal()))
  809.                     return;
  810.           
  811.      Last_char=0;
  812.                
  813.      if(c==CTRL_S)
  814.      {
  815.           c=halt(mode);
  816.      }
  817.      
  818.      Empty_rsbuf();
  819.      
  820.      if(mode!=NBRK && c==CTRL_X)
  821.      {     
  822.           Cr_count=0;
  823.           CRLF;
  824.           longjmp(Break_env,0);
  825.      }
  826.     
  827.      else
  828.           Last_char=c; 
  829. }    
  830.           
  831. halt(mode)    /* wartet auf naechstes Zeichen des Users */
  832. int mode;
  833. {
  834.      int c;
  835.      
  836.      Time=Ti();
  837.      
  838.      Cr_count=0;
  839.  
  840.      do
  841.      {
  842.           if(!(c=Terminal()))
  843.                c=Sterminal();
  844.                
  845.           if(c==CTRL_S)
  846.                c=0;
  847.                
  848.      }
  849.      while(!Tout() && !Carrier_lost() && !c);
  850.           
  851.      Flag->TOUT=0;
  852.      return(c);
  853. }          
  854.  
  855. mbtype(count,buff,mode)  /* gibt Daten ueber Screen und RS232C aus */
  856. register long count;   
  857. register char *buff;
  858. int mode;             
  859. {
  860.  
  861.      long counter=0;
  862.  
  863.      while(counter < count)
  864.      {
  865.           charout(*buff,mode);
  866.           ctrl(mode);
  867.           counter++;
  868.           buff++;
  869.      }
  870. }
  871.  
  872. Mbwrite(count,buff) /* wie Write, jedoch ueber Screen und RS232C */
  873. long count;
  874. char *buff;
  875. {
  876.      mbtype(count,buff,BRK);
  877. }
  878.  
  879.  
  880. handle_ctrl(input,crsr,end,buffer)
  881. int input,*crsr,*end;
  882. char *buffer;
  883. {
  884.      int back=TRUE;
  885.      int i;
  886.     
  887.      switch(input)
  888.      {
  889.           case BS:            if(*crsr>0)
  890.                               {
  891.                                    if(*end == *crsr)
  892.                                    {
  893.                                         buffer[--(*end)]= '\0';
  894.                                         (*crsr)--;
  895.                                         BACKSPACE;
  896.                                    }
  897.                                    
  898.                                    else
  899.                                    {
  900.                                         backdelete(buffer+(*crsr)--);
  901.                                         (*end)--;
  902.                                    }
  903.                               }
  904.                               
  905.                               else
  906.                               {
  907.                                    if(!Flag->BELLOFF)
  908.                                         BELL;
  909.                               }
  910.                               
  911.                               break;
  912.                      
  913.           case DEL:           if(*end>0)
  914.                               {
  915.                                    if(*end == *crsr)
  916.                                    {
  917.                                         buffer[(*end)--]='\0';
  918.                                         (*crsr)--;
  919.                                         BACKSPACE;
  920.                                    }
  921.                                    
  922.                                    else
  923.                                    {
  924.                                         l_delete(buffer+(*crsr));
  925.                                         (*end)--;
  926.                                         
  927.                                         if(*end == *crsr)
  928.                                         {
  929.                                              Flag2->INSERT=0;
  930.                                              VT_OVER;
  931.                                         }     
  932.                                    }
  933.  
  934.                                }
  935.                                
  936.                                else
  937.                                {
  938.                                    if(!Flag->BELLOFF)
  939.                                         BELL;
  940.                                }
  941.                               
  942.                                break;
  943.                                                                           
  944.           case LEFT_ARROW:     if(*crsr>0)
  945.                                {
  946.                                    CRSR_LT;
  947.                                    VT_LEFT;
  948.                                    (*crsr)--;
  949.  
  950.                                    if(!Flag2->INSERT)
  951.                                    {
  952.                                         Flag2->INSERT=1;
  953.                                         VT_INSERT;
  954.                                    }     
  955.                                }
  956.                                         
  957.                                else
  958.                                {
  959.                                    if(!Flag->BELLOFF)
  960.                                         BELL;
  961.                                }
  962.                               
  963.                                break;
  964.                                         
  965.           case RIGHT_ARROW:    if(*crsr < *end)
  966.                                {
  967.                                    CRSR_RT;
  968.                                    VT_RIGHT;
  969.                                    (*crsr)++;
  970.                                    
  971.                                    if(*crsr == *end)
  972.                                    {
  973.                                         Flag2->INSERT=0;
  974.                                         VT_OVER;
  975.                                    }     
  976.                                }
  977.                                         
  978.                                break;
  979.                                         
  980.      }                                        
  981.  
  982.      return(back);
  983. } 
  984.  
  985.  
  986. backdelete(pointer)
  987. char *pointer;
  988. {
  989.      Flag2->EDITLINE=0;
  990.      VT_LEFT;
  991.      CRSR_LT;
  992.      STORE_CRSR;
  993.      CRSR_OFF;
  994.      VT_DEL;
  995.      strcpy(pointer-1,pointer);
  996.      printf("%s ",pointer-1);
  997.      fflush(stdout);
  998.      RESTORE_CRSR;
  999.      CRSR_ON;
  1000. }
  1001.  
  1002. l_delete(pointer)
  1003. char *pointer;
  1004. {
  1005.      Flag2->EDITLINE=0;
  1006.      STORE_CRSR;
  1007.      CRSR_OFF;
  1008.      VT_DEL;
  1009.      strcpy(pointer,pointer+1);
  1010.      printf("%s ",pointer);
  1011.      fflush(stdout);
  1012.      RESTORE_CRSR;
  1013.      CRSR_ON;
  1014. }                                                    
  1015.  
  1016. l_insert(inp,pointer)
  1017. char *pointer;
  1018. int inp;
  1019. {
  1020.      char buffer[190];
  1021.  
  1022.      strcpy(buffer,pointer);
  1023.      *pointer= inp;
  1024.      *(pointer+1)= '\0';
  1025.  
  1026.      Mbputchar(inp,BRK);
  1027.      STORE_CRSR;
  1028.      CRSR_OFF;
  1029.      printf("%s",buffer);
  1030.      fflush(stdout);
  1031.      RESTORE_CRSR;
  1032.      CRSR_ON;
  1033.      strcat(pointer,buffer);
  1034. }
  1035.   
  1036.  
  1037. is_controll(c)
  1038. int c;
  1039. {
  1040.      return(c==BS || c==DEL || c==LEFT_ARROW || c==RIGHT_ARROW);
  1041. }
  1042.  
  1043.  
  1044. Maxtime_exceeded()       /* returns true, if maxtime exceeded    */
  1045. {
  1046.      if(Elapsed_time() < Tmax)
  1047.           return(FALSE);
  1048.  
  1049.      Flag->TMAX=1;
  1050.      return(TRUE);
  1051. }
  1052.  
  1053. long Fetch_ticks()  /* holt ticks aus 200hz-Counter */
  1054. {
  1055.      long save_ssp,ticks;
  1056.      
  1057.      save_ssp=Super(0L);
  1058.      ticks=*hz_200;
  1059.      Super(save_ssp);
  1060.      
  1061.      return(ticks);
  1062. }
  1063.      
  1064. Wait(n)                     /* wartet n millisekunden (kleinste Aufloesung 5 ms) */
  1065. long n;
  1066. {
  1067.      long startticks, ticks, sollticks;
  1068.      
  1069.      sollticks = n/5;              /* ein tick = 5ms */
  1070.      startticks = Fetch_ticks();    
  1071.  
  1072.      for(;;)
  1073.      {
  1074.      
  1075.           ticks=Fetch_ticks()-startticks;
  1076.           
  1077.           if(ticks<0)
  1078.                ticks+=0xEFFFFFFFL;
  1079.                
  1080.           if(ticks>=sollticks)
  1081.                break;
  1082.      }     
  1083. }
  1084.  
  1085.  
  1086. Save_env(source,dest) /* speichert Environment in dest */
  1087. jmp_buf source, dest;
  1088. {
  1089.      int x;
  1090.      
  1091.      for(x=0;x<9;x++)
  1092.           dest[x]=source[x];
  1093. }
  1094.  
  1095. Zeit()
  1096. {
  1097.  
  1098.  
  1099.      int time;
  1100.      ZEITFELD *pointer;
  1101.      
  1102.      pointer=(ZEITFELD *)&time;
  1103.      
  1104.      time = Tgettime();
  1105.      Uhrzeit.STUNDEN = pointer->hour;
  1106.      Uhrzeit.MINUTEN = pointer->min;
  1107.      Uhrzeit.SEKUNDEN = pointer->sec * 2;
  1108. }
  1109.  
  1110. Carrier_lost()     /* True wenn weder Carrier noch Lokalbetrieb */
  1111. {
  1112.      int flag;
  1113.      flag = !Carrier() && !Flag->LOCAL;
  1114.      Flag->CARRIER_LOST = flag;
  1115.      return(flag);
  1116. }
  1117.  
  1118. Tout()                    /* True, wenn Timeout   */
  1119. {
  1120.      int flag = FALSE;
  1121.      long x;
  1122.  
  1123.      x = Ti() - Time;
  1124.    
  1125.      if(x < 0L)
  1126.           x += 86400;
  1127.           
  1128.      if(x > ((long) Touttime))
  1129.      {
  1130.           flag = TRUE;
  1131.           Flag->TOUT = TRUE;
  1132.      }
  1133.      
  1134.      return(flag);
  1135. }
  1136.  
  1137. prepare()        /* exit vorbereiten */
  1138. {
  1139.      Flag2->EDITLINE=0;
  1140.      Flag2->INSERT=0;
  1141.      VT_OVER;
  1142. }
  1143.  
  1144. /****************************************************************************
  1145.  
  1146.      Beginn von main mit ein paar Beispielen
  1147.      
  1148. ****************************************************************************/
  1149.  
  1150. main(argc,argv)     /* Start des Programms */
  1151. int argc;
  1152. char *argv[];
  1153. {
  1154.      char inputbuffer[21];
  1155.      
  1156.      if(argc==1)
  1157.           exit(1);                        /* ohne Argumente wollen wir nicht */
  1158.  
  1159.      App_par=(APP_PAR *)atol(argv[1]);    /* wir holen Variablen */
  1160.     
  1161.      Flag=(FLAG *)(App_par->APP_FLAG);
  1162.      Flag2=(FLAG2 *)(App_par->APP_FLAG2);
  1163.      User=(USER *)(App_par->APP_USER);
  1164.      Calls=App_par->APP_CALLS;
  1165.      Tmax=App_par->APP_TMAX;
  1166.      Login_time=App_par->APP_LOGINTIME;
  1167.      new_rsiorec = (RSIOREC *)Iorec(0);
  1168.      Convert_iarray=App_par->APP_ICNVRT;
  1169.      Convert_oarray=App_par->APP_OCNVRT;
  1170.      Screensize=App_par->APP_SCREENSIZE;          
  1171.  
  1172. /* Diese Stelle wird angesprungen bei Verlust des Carriers, Timeout
  1173.    oder Ueberschreiten der maximalen Benutzerzeit                        */
  1174.    
  1175.      if(setjmp(Terminate_env))
  1176.      {
  1177.           prepare();
  1178.           exit(1);
  1179.      }
  1180.           
  1181.      CRLF;          /* Leerzeilen nach Programmstart, Break_env braucht */
  1182.      CRLF;          /* noch nicht gesetzt zu werden. da CTRL_X nicht    */
  1183.                     /* moeglich ist */
  1184.                     /* bei Mbprintf fuer Zeilenvorschub immer \r\n ver  */
  1185.                     /* wenden !!                                        */
  1186.  
  1187.      Mbprintf(NBRK,"         TESTAPPLIKATION\r\n");
  1188.      Mbprintf(NBRK,"         ===============\r\n\r\n\r\n");      
  1189.      Mbprintf(NBRK,"Moechtest Du eine Anleitung (J/N)?>");
  1190.      Mbgets(inputbuffer,20); /* Antwort mit maximal 20 Zeichen holen */
  1191.      
  1192.      Empty_rsbuf(); /* sicherheitshalber Inputbuffer loeschen           */
  1193.      
  1194.      if(!setjmp(Break_env)) /* es folgen Ausgaben, die mit CTRL_X abge- */
  1195.      {                      /* brochen werden koennen, deswegen muss    */
  1196.                             /* Break_env gesetzt werden                 */
  1197.                             
  1198.           if(*inputbuffer=='J' || *inputbuffer=='j')
  1199.           {
  1200.                Mbprintf(BRK,"\r\nDas ist ein Beispiel fuer eine Gebrauchsanweisung, die natuerlich\r\n");
  1201.                Mbprintf(BRK,"hier nur einen totalen Unsinnstext bringt. Es wird aber gezeigt,\r\n");
  1202.                Mbprintf(BRK,"dass hier ein Text ausgegeben wird, der sich abbrechen laesst.\r\n");
  1203.           }
  1204.      }
  1205.      
  1206.      *inputbuffer='\0';
  1207.      
  1208.      while(strcmp(inputbuffer,"ENDE"))
  1209.      {     
  1210.           Mbprintf(NBRK,"\r\nWas nun %s (Spiel,Ende)?>",User->NAME);
  1211.           Mbgets(inputbuffer,20);
  1212.           Change(inputbuffer);       /* Antwort in Grossbuchstaben umsetzen */
  1213.           
  1214.           CRLF;
  1215.           
  1216.           if(!strcmp(inputbuffer,"SPIEL"))
  1217.                Mbprintf(NBRK,"Das waere das Spiel...\r\n");
  1218.                
  1219.           else
  1220.           {
  1221.                if(strcmp(inputbuffer,"ENDE"))
  1222.                     Mbprintf(NBRK,"Eingabefehler!!!\r\n");
  1223.           }
  1224.      }
  1225.      
  1226.      /* Spieler hat Ende gewaehlt, es kommt nun noch etwas Bla-bla, um zu */
  1227.      /* zu zeigen, dass vor jeder abbrechbaren Ausgabe Break_env gesetzt  */
  1228.      /* werden muss                                                       */
  1229.      
  1230.      if(!setjmp(Break_env))
  1231.      {
  1232.           Mbprintf(BRK,"Ich hoffe, Dir hat das Spiel gefallen %s und Du startest es bald mal\r\nwieder.\r\n\r\n",User->NAME);
  1233.           Mbprintf(BRK,"Statistik\r\n");
  1234.           Mbprintf(BRK,"=========\r\n\r\n");
  1235.           Mbprintf(BRK,"Zeit im System %d min.\r\n",Elapsed_time());
  1236.           Mbprintf(BRK,"Anrufer insgesamt %ld\r\n",Calls);
  1237.           Mbprintf(BRK,"Deine Anrufe bisher %ld\r\n\r\n",atol(User->CALLS));
  1238.      }
  1239.  
  1240.      prepare();                        
  1241. }
  1242.                              
  1243.